home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1997 October: Mac OS SDK / Dev.CD Oct 97 SDK1.toast / Development Kits (Disc 1) / Interfaces&Libraries / Universal / Interfaces / PInterfaces / PPCToolbox.p < prev    next >
Encoding:
Text File  |  1997-08-12  |  18.6 KB  |  494 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        PPCToolbox.p
  3.  
  4.      Contains:    Program-Program Communications Toolbox Interfaces.
  5.  
  6.      Version:    Technology:    System 7.5
  7.                  Release:    Universal Interfaces 3.0.1
  8.  
  9.      Copyright:    © 1989-1993, 1995-1997 by Apple Computer, Inc., all rights reserved
  10.  
  11.      Bugs?:        Please include the the file and version information (from above) with
  12.                  the problem description.  Developers belonging to one of the Apple
  13.                  developer programs can submit bug reports to:
  14.  
  15.                      devsupport@apple.com
  16.  
  17. }
  18. {$IFC UNDEFINED UsingIncludes}
  19. {$SETC UsingIncludes := 0}
  20. {$ENDC}
  21.  
  22. {$IFC NOT UsingIncludes}
  23.  UNIT PPCToolbox;
  24.  INTERFACE
  25. {$ENDC}
  26.  
  27. {$IFC UNDEFINED __PPCTOOLBOX__}
  28. {$SETC __PPCTOOLBOX__ := 1}
  29.  
  30. {$I+}
  31. {$SETC PPCToolboxIncludes := UsingIncludes}
  32. {$SETC UsingIncludes := 1}
  33.  
  34. {$IFC UNDEFINED __TYPES__}
  35. {$I Types.p}
  36. {$ENDC}
  37. {$IFC UNDEFINED __APPLETALK__}
  38. {$I AppleTalk.p}
  39. {$ENDC}
  40.  
  41.  
  42. {$PUSH}
  43. {$ALIGN MAC68K}
  44. {$LibExport+}
  45.  
  46.  
  47. TYPE
  48.     PPCServiceType                        = UInt8;
  49.  
  50. CONST
  51.     ppcServiceRealTime            = 1;
  52.  
  53.  
  54. TYPE
  55.     PPCLocationKind                        = INTEGER;
  56.  
  57. CONST
  58.     ppcNoLocation                = 0;                            {  There is no PPCLocName  }
  59.     ppcNBPLocation                = 1;                            {  Use AppleTalk NBP       }
  60.     ppcNBPTypeLocation            = 2;                            {  Used for specifying a location name type during PPCOpen only  }
  61.  
  62.  
  63. TYPE
  64.     PPCPortKinds                        = INTEGER;
  65.  
  66. CONST
  67.     ppcByCreatorAndType            = 1;                            {  Port type is specified as colloquial Mac creator and type  }
  68.     ppcByString                    = 2;                            {  Port type is in pascal string format  }
  69.  
  70. { Values returned for request field in PPCInform call }
  71.  
  72. TYPE
  73.     PPCSessionOrigin                    = UInt8;
  74.  
  75. CONST
  76.                                                                 {  Values returned for requestType field in PPCInform call  }
  77.     ppcLocalOrigin                = 1;                            {  session originated from this machine  }
  78.     ppcRemoteOrigin                = 2;                            {  session originated from remote machine  }
  79.  
  80.  
  81. TYPE
  82.     PPCPortRefNum                        = INTEGER;
  83.     PPCSessRefNum                        = LONGINT;
  84.     PPCPortRecPtr = ^PPCPortRec;
  85.     PPCPortRec = RECORD
  86.         nameScript:                ScriptCode;                                {  script of name  }
  87.         name:                    Str32Field;                                {  name of port as seen in browser  }
  88.         portKindSelector:        PPCPortKinds;                            {  which variant  }
  89.         CASE INTEGER OF
  90.         0: (
  91.             portTypeStr:        Str32;                                    {  pascal type string  }
  92.             );
  93.         1: (
  94.             portCreator:        OSType;
  95.             portType:            OSType;
  96.            );
  97.     END;
  98.  
  99.     PPCPortPtr                            = ^PPCPortRec;
  100.     LocationNameRecPtr = ^LocationNameRec;
  101.     LocationNameRec = RECORD
  102.         locationKindSelector:    PPCLocationKind;                        {  which variant  }
  103.         CASE INTEGER OF
  104.         0: (
  105.             nbpEntity:            EntityName;                                {  NBP name entity  }
  106.             );
  107.         1: (
  108.             nbpType:            Str32;                                    {  just the NBP type string, for PPCOpen  }
  109.             );
  110.     END;
  111.  
  112.     LocationNamePtr                        = ^LocationNameRec;
  113.     PortInfoRecPtr = ^PortInfoRec;
  114.     PortInfoRec = RECORD
  115.         filler1:                SInt8;
  116.         authRequired:            BOOLEAN;
  117.         name:                    PPCPortRec;
  118.     END;
  119.  
  120.     PortInfoPtr                            = ^PortInfoRec;
  121.     PortInfoArrayPtr                    = ^PortInfoRec;
  122.     PPCParamBlockRecPtr = ^PPCParamBlockRec;
  123.     PPCParamBlockPtr                    = ^PPCParamBlockRec;
  124.     PPCCompProcPtr = ProcPtr;  { PROCEDURE PPCComp(pb: PPCParamBlockPtr); }
  125.  
  126.     PPCCompUPP = UniversalProcPtr;
  127.     PPCOpenPBRecPtr = ^PPCOpenPBRec;
  128.     PPCOpenPBRec = PACKED RECORD
  129.         qLink:                    Ptr;                                    {  PPC's Internal Use  }
  130.         csCode:                    INTEGER;                                {  Requested PPC command  }
  131.         intUse:                    INTEGER;                                {  Internal Use  }
  132.         intUsePtr:                Ptr;                                    {  Internal Use  }
  133.         ioCompletion:            PPCCompUPP;                                {  12 -->    Completion Routine  }
  134.         ioResult:                OSErr;                                    {  16 <--     Command Result Code  }
  135.         Reserved:                ARRAY [0..4] OF LONGINT;                {  Reserved for PPC, Don't use  }
  136.         portRefNum:                PPCPortRefNum;                            {  38 <--   Port Reference  }
  137.         filler1:                LONGINT;
  138.         serviceType:            PPCServiceType;                            {  44 -->    Bit field describing the requested port service  }
  139.         resFlag:                UInt8;                                    {  Must be set to 0  }
  140.         portName:                PPCPortPtr;                                {  46 -->   PortName for PPC  }
  141.         locationName:            LocationNamePtr;                        {  50 -->   If NBP Registration is required  }
  142.         networkVisible:            BOOLEAN;                                {  54 -->   make this network visible on network  }
  143.         nbpRegistered:            BOOLEAN;                                {  55 <--   The given location name was registered on the network  }
  144.     END;
  145.  
  146.     PPCOpenPBPtr                        = ^PPCOpenPBRec;
  147.     PPCInformPBRecPtr = ^PPCInformPBRec;
  148.     PPCInformPBRec = PACKED RECORD
  149.         qLink:                    Ptr;                                    {  PPC's Internal Use  }
  150.         csCode:                    INTEGER;                                {  Requested PPC command  }
  151.         intUse:                    INTEGER;                                {  Internal Use  }
  152.         intUsePtr:                Ptr;                                    {  Internal Use  }
  153.         ioCompletion:            PPCCompUPP;                                {  12 -->    Completion Routine  }
  154.         ioResult:                OSErr;                                    {  16 <--     Command Result Code  }
  155.         Reserved:                ARRAY [0..4] OF LONGINT;                {  Reserved for PPC, Don't use  }
  156.         portRefNum:                PPCPortRefNum;                            {  38 -->   Port Identifier  }
  157.         sessRefNum:                PPCSessRefNum;                            {  40 <--   Session Reference  }
  158.         serviceType:            PPCServiceType;                            {  44 <--   Status Flags for type of session, local, remote  }
  159.         autoAccept:                BOOLEAN;                                {  45 -->   if true session will be accepted automatically  }
  160.         portName:                PPCPortPtr;                                {  46 -->   Buffer for Source PPCPortRec  }
  161.         locationName:            LocationNamePtr;                        {  50 -->   Buffer for Source LocationNameRec  }
  162.         userName:                StringPtr;                                {  54 -->   Buffer for Soure user's name trying to link.  }
  163.         userData:                LONGINT;                                {  58 <--   value included in PPCStart's userData  }
  164.         requestType:            PPCSessionOrigin;                        {  62 <--   Local or Network  }
  165.         filler:                    SInt8;
  166.     END;
  167.  
  168.     PPCInformPBPtr                        = ^PPCInformPBRec;
  169.     PPCStartPBRecPtr = ^PPCStartPBRec;
  170.     PPCStartPBRec = PACKED RECORD
  171.         qLink:                    Ptr;                                    {  PPC's Internal Use  }
  172.         csCode:                    INTEGER;                                {  Requested PPC command  }
  173.         intUse:                    INTEGER;                                {  Internal Use  }
  174.         intUsePtr:                Ptr;                                    {  Internal Use  }
  175.         ioCompletion:            PPCCompUPP;                                {  12 -->    Completion Routine  }
  176.         ioResult:                OSErr;                                    {  16 <--     Command Result Code  }
  177.         Reserved:                ARRAY [0..4] OF LONGINT;                {  Reserved for PPC, Don't use  }
  178.         portRefNum:                PPCPortRefNum;                            {  38 -->   Port Identifier  }
  179.         sessRefNum:                PPCSessRefNum;                            {  40 <--   Session Reference  }
  180.         serviceType:            PPCServiceType;                            {  44 <--   Actual service method (realTime)  }
  181.         resFlag:                UInt8;                                    {  45 -->   Must be set to 0   }
  182.         portName:                PPCPortPtr;                                {  46 -->   Destination portName  }
  183.         locationName:            LocationNamePtr;                        {  50 -->   NBP or NAS style service location name  }
  184.         rejectInfo:                LONGINT;                                {  54 <--   reason for rejecting the session request  }
  185.         userData:                LONGINT;                                {  58 -->   Copied to destination PPCInform parameter block  }
  186.         userRefNum:                LONGINT;                                {  62 -->   userRefNum (obtained during login process)   }
  187.     END;
  188.  
  189.     PPCStartPBPtr                        = ^PPCStartPBRec;
  190.     PPCAcceptPBRecPtr = ^PPCAcceptPBRec;
  191.     PPCAcceptPBRec = RECORD
  192.         qLink:                    Ptr;                                    {  PPC's Internal Use  }
  193.         csCode:                    INTEGER;                                {  Requested PPC command  }
  194.         intUse:                    INTEGER;                                {  Internal Use  }
  195.         intUsePtr:                Ptr;                                    {  Internal Use  }
  196.         ioCompletion:            PPCCompUPP;                                {  12 -->    Completion Routine  }
  197.         ioResult:                OSErr;                                    {  16 <--     Command Result Code  }
  198.         Reserved:                ARRAY [0..4] OF LONGINT;                {  Reserved for PPC, Don't use  }
  199.         filler1:                INTEGER;
  200.         sessRefNum:                PPCSessRefNum;                            {  40 -->   Session Reference  }
  201.     END;
  202.  
  203.     PPCAcceptPBPtr                        = ^PPCAcceptPBRec;
  204.     PPCRejectPBRecPtr = ^PPCRejectPBRec;
  205.     PPCRejectPBRec = RECORD
  206.         qLink:                    Ptr;                                    {  PPC's Internal Use  }
  207.         csCode:                    INTEGER;                                {  Requested PPC command  }
  208.         intUse:                    INTEGER;                                {  Internal Use  }
  209.         intUsePtr:                Ptr;                                    {  Internal Use  }
  210.         ioCompletion:            PPCCompUPP;                                {  12 -->    Completion Routine  }
  211.         ioResult:                OSErr;                                    {  16 <--     Command Result Code  }
  212.         Reserved:                ARRAY [0..4] OF LONGINT;                {  Reserved for PPC, Don't use  }
  213.         filler1:                INTEGER;
  214.         sessRefNum:                PPCSessRefNum;                            {  40 -->   Session Reference  }
  215.         filler2:                INTEGER;
  216.         filler3:                LONGINT;
  217.         filler4:                LONGINT;
  218.         rejectInfo:                LONGINT;                                {  54 -->   reason for rejecting the session request   }
  219.     END;
  220.  
  221.     PPCRejectPBPtr                        = ^PPCRejectPBRec;
  222.     PPCWritePBRecPtr = ^PPCWritePBRec;
  223.     PPCWritePBRec = RECORD
  224.         qLink:                    Ptr;                                    {  PPC's Internal Use  }
  225.         csCode:                    INTEGER;                                {  Requested PPC command  }
  226.         intUse:                    INTEGER;                                {  Internal Use  }
  227.         intUsePtr:                Ptr;                                    {  Internal Use  }
  228.         ioCompletion:            PPCCompUPP;                                {  12 -->    Completion Routine  }
  229.         ioResult:                OSErr;                                    {  16 <--     Command Result Code  }
  230.         Reserved:                ARRAY [0..4] OF LONGINT;                {  Reserved for PPC, Don't use  }
  231.         filler1:                INTEGER;
  232.         sessRefNum:                PPCSessRefNum;                            {  40 -->   Session Reference  }
  233.         bufferLength:            Size;                                    {  44 -->   Length of the message buffer  }
  234.         actualLength:            Size;                                    {  48 <--   Actual Length Written  }
  235.         bufferPtr:                Ptr;                                    {  52 -->   Pointer to message buffer  }
  236.         more:                    BOOLEAN;                                {  56 -->   if more data in this block will be written  }
  237.         filler2:                SInt8;
  238.         userData:                LONGINT;                                {  58 -->   Message block userData Uninterpreted by PPC  }
  239.         blockCreator:            OSType;                                    {  62 -->   Message block creator Uninterpreted by PPC  }
  240.         blockType:                OSType;                                    {  66 -->   Message block type Uninterpreted by PPC  }
  241.     END;
  242.  
  243.     PPCWritePBPtr                        = ^PPCWritePBRec;
  244.     PPCReadPBRecPtr = ^PPCReadPBRec;
  245.     PPCReadPBRec = RECORD
  246.         qLink:                    Ptr;                                    {  PPC's Internal Use  }
  247.         csCode:                    INTEGER;                                {  Requested PPC command  }
  248.         intUse:                    INTEGER;                                {  Internal Use  }
  249.         intUsePtr:                Ptr;                                    {  Internal Use  }
  250.         ioCompletion:            PPCCompUPP;                                {  12 -->    Completion Routine  }
  251.         ioResult:                OSErr;                                    {  16 <--     Command Result Code  }
  252.         Reserved:                ARRAY [0..4] OF LONGINT;                {  Reserved for PPC, Don't use  }
  253.         filler1:                INTEGER;
  254.         sessRefNum:                PPCSessRefNum;                            {  40 -->   Session Reference  }
  255.         bufferLength:            Size;                                    {  44 -->   Length of the message buffer  }
  256.         actualLength:            Size;                                    {  48 <--   Actual length read  }
  257.         bufferPtr:                Ptr;                                    {  52 -->   Pointer to message buffer  }
  258.         more:                    BOOLEAN;                                {  56 <--   if true more data in this block to be read  }
  259.         filler2:                SInt8;
  260.         userData:                LONGINT;                                {  58 <--   Message block userData Uninterpreted by PPC  }
  261.         blockCreator:            OSType;                                    {  62 <--   Message block creator Uninterpreted by PPC  }
  262.         blockType:                OSType;                                    {  66 <--   Message block type Uninterpreted by PPC  }
  263.     END;
  264.  
  265.     PPCReadPBPtr                        = ^PPCReadPBRec;
  266.     PPCEndPBRecPtr = ^PPCEndPBRec;
  267.     PPCEndPBRec = RECORD
  268.         qLink:                    Ptr;                                    {  PPC's Internal Use  }
  269.         csCode:                    INTEGER;                                {  Requested PPC command  }
  270.         intUse:                    INTEGER;                                {  Internal Use  }
  271.         intUsePtr:                Ptr;                                    {  Internal Use  }
  272.         ioCompletion:            PPCCompUPP;                                {  12 -->    Completion Routine  }
  273.         ioResult:                OSErr;                                    {  16 <--     Command Result Code  }
  274.         Reserved:                ARRAY [0..4] OF LONGINT;                {  Reserved for PPC, Don't use  }
  275.         filler1:                INTEGER;
  276.         sessRefNum:                PPCSessRefNum;                            {  40 -->   Session Reference  }
  277.     END;
  278.  
  279.     PPCEndPBPtr                            = ^PPCEndPBRec;
  280.     PPCClosePBRecPtr = ^PPCClosePBRec;
  281.     PPCClosePBRec = RECORD
  282.         qLink:                    Ptr;                                    {  PPC's Internal Use  }
  283.         csCode:                    INTEGER;                                {  Requested PPC command  }
  284.         intUse:                    INTEGER;                                {  Internal Use  }
  285.         intUsePtr:                Ptr;                                    {  Internal Use  }
  286.         ioCompletion:            PPCCompUPP;                                {  12 -->    Completion Routine  }
  287.         ioResult:                OSErr;                                    {  16 <--     Command Result Code  }
  288.         Reserved:                ARRAY [0..4] OF LONGINT;                {  Reserved for PPC, Don't use  }
  289.         portRefNum:                PPCPortRefNum;                            {  38 -->   Port Identifier  }
  290.     END;
  291.  
  292.     PPCClosePBPtr                        = ^PPCClosePBRec;
  293.     IPCListPortsPBRecPtr = ^IPCListPortsPBRec;
  294.     IPCListPortsPBRec = RECORD
  295.         qLink:                    Ptr;                                    {  PPC's Internal Use  }
  296.         csCode:                    INTEGER;                                {  Requested PPC command  }
  297.         intUse:                    INTEGER;                                {  Internal Use  }
  298.         intUsePtr:                Ptr;                                    {  Internal Use  }
  299.         ioCompletion:            PPCCompUPP;                                {  12 -->    Completion Routine  }
  300.         ioResult:                OSErr;                                    {  16 <--     Command Result Code  }
  301.         Reserved:                ARRAY [0..4] OF LONGINT;                {  Reserved for PPC, Don't use  }
  302.         filler1:                INTEGER;
  303.         startIndex:                INTEGER;                                {  40 -->   Start Index  }
  304.         requestCount:            INTEGER;                                {  42 -->   Number of entries to be returned  }
  305.         actualCount:            INTEGER;                                {  44 <--   Actual Number of entries to be returned  }
  306.         portName:                PPCPortPtr;                                {  46 -->   PortName Match  }
  307.         locationName:            LocationNamePtr;                        {  50 -->   NBP or NAS type name to locate the Port Location  }
  308.         bufferPtr:                PortInfoArrayPtr;                        {  54 -->   Pointer to a buffer requestCount*sizeof(PortInfo) bytes big  }
  309.     END;
  310.  
  311.     IPCListPortsPBPtr                    = ^IPCListPortsPBRec;
  312.     PPCParamBlockRec = RECORD
  313.         CASE INTEGER OF
  314.         0: (
  315.             openParam:            PPCOpenPBRec;
  316.             );
  317.         1: (
  318.             informParam:        PPCInformPBRec;
  319.             );
  320.         2: (
  321.             startParam:            PPCStartPBRec;
  322.             );
  323.         3: (
  324.             acceptParam:        PPCAcceptPBRec;
  325.             );
  326.         4: (
  327.             rejectParam:        PPCRejectPBRec;
  328.             );
  329.         5: (
  330.             writeParam:            PPCWritePBRec;
  331.             );
  332.         6: (
  333.             readParam:            PPCReadPBRec;
  334.             );
  335.         7: (
  336.             endParam:            PPCEndPBRec;
  337.             );
  338.         8: (
  339.             closeParam:            PPCClosePBRec;
  340.             );
  341.         9: (
  342.             listPortsParam:        IPCListPortsPBRec;
  343.             );
  344.     END;
  345.  
  346. {  PPC Calling Conventions  }
  347. FUNCTION PPCInit: OSErr;
  348.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  349.     INLINE $7000, $A0DD, $3E80;
  350.     {$ENDC}
  351.  
  352. FUNCTION PPCOpenSync(pb: PPCOpenPBPtr): OSErr;
  353.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  354.     INLINE $205F, $7001, $A0DD, $3E80;
  355.     {$ENDC}
  356. FUNCTION PPCOpenAsync(pb: PPCOpenPBPtr): OSErr;
  357.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  358.     INLINE $205F, $7001, $A4DD, $3E80;
  359.     {$ENDC}
  360. FUNCTION PPCInformSync(pb: PPCInformPBPtr): OSErr;
  361.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  362.     INLINE $205F, $7003, $A0DD, $3E80;
  363.     {$ENDC}
  364. FUNCTION PPCInformAsync(pb: PPCInformPBPtr): OSErr;
  365.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  366.     INLINE $205F, $7003, $A4DD, $3E80;
  367.     {$ENDC}
  368. FUNCTION PPCStartSync(pb: PPCStartPBPtr): OSErr;
  369.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  370.     INLINE $205F, $7002, $A0DD, $3E80;
  371.     {$ENDC}
  372. FUNCTION PPCStartAsync(pb: PPCStartPBPtr): OSErr;
  373.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  374.     INLINE $205F, $7002, $A4DD, $3E80;
  375.     {$ENDC}
  376. FUNCTION PPCAcceptSync(pb: PPCAcceptPBPtr): OSErr;
  377.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  378.     INLINE $205F, $7004, $A0DD, $3E80;
  379.     {$ENDC}
  380. FUNCTION PPCAcceptAsync(pb: PPCAcceptPBPtr): OSErr;
  381.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  382.     INLINE $205F, $7004, $A4DD, $3E80;
  383.     {$ENDC}
  384. FUNCTION PPCRejectSync(pb: PPCRejectPBPtr): OSErr;
  385.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  386.     INLINE $205F, $7005, $A0DD, $3E80;
  387.     {$ENDC}
  388. FUNCTION PPCRejectAsync(pb: PPCRejectPBPtr): OSErr;
  389.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  390.     INLINE $205F, $7005, $A4DD, $3E80;
  391.     {$ENDC}
  392. FUNCTION PPCWriteSync(pb: PPCWritePBPtr): OSErr;
  393.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  394.     INLINE $205F, $7006, $A0DD, $3E80;
  395.     {$ENDC}
  396. FUNCTION PPCWriteAsync(pb: PPCWritePBPtr): OSErr;
  397.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  398.     INLINE $205F, $7006, $A4DD, $3E80;
  399.     {$ENDC}
  400. FUNCTION PPCReadSync(pb: PPCReadPBPtr): OSErr;
  401.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  402.     INLINE $205F, $7007, $A0DD, $3E80;
  403.     {$ENDC}
  404. FUNCTION PPCReadAsync(pb: PPCReadPBPtr): OSErr;
  405.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  406.     INLINE $205F, $7007, $A4DD, $3E80;
  407.     {$ENDC}
  408. FUNCTION PPCEndSync(pb: PPCEndPBPtr): OSErr;
  409.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  410.     INLINE $205F, $7008, $A0DD, $3E80;
  411.     {$ENDC}
  412. FUNCTION PPCEndAsync(pb: PPCEndPBPtr): OSErr;
  413.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  414.     INLINE $205F, $7008, $A4DD, $3E80;
  415.     {$ENDC}
  416. FUNCTION PPCCloseSync(pb: PPCClosePBPtr): OSErr;
  417.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  418.     INLINE $205F, $7009, $A0DD, $3E80;
  419.     {$ENDC}
  420. FUNCTION PPCCloseAsync(pb: PPCClosePBPtr): OSErr;
  421.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  422.     INLINE $205F, $7009, $A4DD, $3E80;
  423.     {$ENDC}
  424. FUNCTION IPCListPortsSync(pb: IPCListPortsPBPtr): OSErr;
  425.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  426.     INLINE $205F, $700A, $A0DD, $3E80;
  427.     {$ENDC}
  428. FUNCTION IPCListPortsAsync(pb: IPCListPortsPBPtr): OSErr;
  429.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  430.     INLINE $205F, $700A, $A4DD, $3E80;
  431.     {$ENDC}
  432. FUNCTION DeleteUserIdentity(userRef: LONGINT): OSErr;
  433. FUNCTION GetDefaultUser(VAR userRef: LONGINT; VAR userName: Str32): OSErr;
  434. FUNCTION StartSecureSession(pb: PPCStartPBPtr; VAR userName: Str32; useDefault: BOOLEAN; allowGuest: BOOLEAN; VAR guestSelected: BOOLEAN; prompt: ConstStr255Param): OSErr;
  435.  
  436. TYPE
  437.     PPCFilterProcPtr = ProcPtr;  { FUNCTION PPCFilter(name: LocationNamePtr; port: PortInfoPtr): BOOLEAN; }
  438.  
  439.     PPCFilterUPP = UniversalProcPtr;
  440.  
  441. CONST
  442.     uppPPCCompProcInfo = $000000C0;
  443.     uppPPCFilterProcInfo = $000003D0;
  444.  
  445. FUNCTION NewPPCCompProc(userRoutine: PPCCompProcPtr): PPCCompUPP;
  446.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  447.     INLINE $2E9F;
  448.     {$ENDC}
  449.  
  450. FUNCTION NewPPCFilterProc(userRoutine: PPCFilterProcPtr): PPCFilterUPP;
  451.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  452.     INLINE $2E9F;
  453.     {$ENDC}
  454.  
  455. PROCEDURE CallPPCCompProc(pb: PPCParamBlockPtr; userRoutine: PPCCompUPP);
  456.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  457.     INLINE $205F, $4E90;
  458.     {$ENDC}
  459.  
  460. FUNCTION CallPPCFilterProc(name: LocationNamePtr; port: PortInfoPtr; userRoutine: PPCFilterUPP): BOOLEAN;
  461.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  462.     INLINE $205F, $4E90;
  463.     {$ENDC}
  464. FUNCTION PPCBrowser(prompt: ConstStr255Param; applListLabel: ConstStr255Param; defaultSpecified: BOOLEAN; VAR theLocation: LocationNameRec; VAR thePortInfo: PortInfoRec; portFilter: PPCFilterUPP; theLocNBPType: ConstStr32Param): OSErr;
  465.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  466.     INLINE $303C, $0D00, $A82B;
  467.     {$ENDC}
  468.  
  469. {
  470.   The ParamBlock calls with the "Sync" or "Async" suffix are being phased out.
  471. }
  472. FUNCTION PPCOpen(pb: PPCOpenPBPtr; async: BOOLEAN): OSErr;
  473. FUNCTION PPCInform(pb: PPCInformPBPtr; async: BOOLEAN): OSErr;
  474. FUNCTION PPCStart(pb: PPCStartPBPtr; async: BOOLEAN): OSErr;
  475. FUNCTION PPCAccept(pb: PPCAcceptPBPtr; async: BOOLEAN): OSErr;
  476. FUNCTION PPCReject(pb: PPCRejectPBPtr; async: BOOLEAN): OSErr;
  477. FUNCTION PPCWrite(pb: PPCWritePBPtr; async: BOOLEAN): OSErr;
  478. FUNCTION PPCRead(pb: PPCReadPBPtr; async: BOOLEAN): OSErr;
  479. FUNCTION PPCEnd(pb: PPCEndPBPtr; async: BOOLEAN): OSErr;
  480. FUNCTION PPCClose(pb: PPCClosePBPtr; async: BOOLEAN): OSErr;
  481. FUNCTION IPCListPorts(pb: IPCListPortsPBPtr; async: BOOLEAN): OSErr;
  482.  
  483.  
  484. {$ALIGN RESET}
  485. {$POP}
  486.  
  487. {$SETC UsingIncludes := PPCToolboxIncludes}
  488.  
  489. {$ENDC} {__PPCTOOLBOX__}
  490.  
  491. {$IFC NOT UsingIncludes}
  492.  END.
  493. {$ENDC}
  494.